Heterogeneous system on chips like the Zynq are ideal for motor control applications. The programmable logic means we can implement complex control algorithms and interface with both industry standard and bespoke interfaces.

As I go to a lot of conferences and exhibitions I wanted to create a compact motor control application which show cased how the Zynq can be used for this.

I wanted this demo to be compact and demonstrate the power of the Zynq, even when using one of the smaller Zynq devices. I therefore decided to use the MiniZed which uses the smallest of the single core Zynq devices.

The architecture of the design will be the following.

Controlling the motor is fairly straight forward, to enable a logic level FPGA output to supply a higher voltage needed by most DC motors we use a circuit called a H-Bridge.

The H-Bridge allows us to supply not only a higher voltage but also to be able to control the direction of the motor depending upon a direction signal.

The simplest FPGA H-Bridge control circuit uses two digital control lines, one for the direction and the second to enable the voltage supply to the motor. While this approach works, it provides a very digital motor control, either the motor is running at its full voltage or it is off.

Of course when the maximum voltage is applied to the motor the speed of rotation will be at its maximum. In our applications we need to be able

A more granular control of the motor can be achieved using Pulse Width Modulation (PWM). PWM enables us to control the average voltage across the motor by switching the voltage on and off with a set period repeated pattern.

Increasing the duty cycle results in a higher average voltage across the motor and hence a higher motor speed. Similarly decreasing the duty cycle reduces the average voltage across the motor and lowers the motor speed.

This provides a very granular control of the motor speed.

The hardware design created in Vivado, as we are using the MiniZed we will create a project which uses the MiniZed as the target board.

Into the new project we are going to add in a Zynq processing system and run the block automation to configure the processing system correctly for the MiniZed.

Once we have configured the processing system for the MiniZed we need to customise the processing system for our application. In this case we need to enable the Master General Purpose AXI interface from the processing system to the programmable logic.

To this we will be adding in the following IP

Once this is added we can run the connection automation, to connect the PmodMTDS into the processing system

As we are using the PmodMTDS to the arduino shield connector, we need to re customise the PmodMTDS IP block to use the SPI and not Pmod.

The PmodMTDS will allow us to have display and control the motor, what we need to do now is implement the direction signal and the PWM output.

To do this we will be using elements within the processing system itself, for the direction we will be using a GPIO signal routed to the EMIO. The PWM signal itself will be provided by the Triple Timer Counter.

Each TTC contains three timers, each of which is able to generate a PWM output. Within the Zynq PS we have two TTCs.

This means we are able to generate up to six PWM signals from the processing system.

If we want to control more than six motors using PWM, we can implement additional PWM IP functions in the programmable logic.

To ensure the PmodMTDS can function correctly we also need to enable interrupts from the programmable logic to the processing system

Once all of this is completed in Vivado the block diagram should look as below.

Once the build is completed we can export the design to SDK and generate the software application

Inside SDK once the hardware platform has been imported, the next step is to create a Board Support Package.

When the dialog is shown to customise the BSP ensure the stdin / stdout are set to ps7_uart_1

Once the BSP is generated, we are ready to create the application project this will be a C++ project.

The software architecture of the design is as follows:

Within the main application, there will be 9 buttons, six of the buttons will provide different speeds while the remaining three will set the direction or stop the motor.

Setting up the tick once the interrupt controller and timer are configured:

Setting up the interrupt controller:

Setting up the TTC:

TTC interrupt service routine:

Main program:

Once this code was all up and running on the board, before I could connect it to the motor I wanted to double check the PWM was correct and the directions signal change was safe.

If we change the direction at the same time as we are applying PWM signal, then there is potential for a short circuit and damage to be caused.

To test this I connected a oscilloscope to the Pmod outputs and ensured the PWM signal was as expected.

Once I was happy with the PWM output and the safe changing of directions, I connected a motor to the board and tested out all of the different speeds. In the video below you can see the speed changing (and the drive current) as the different speeds are set on the touch screen.

We also see the direction changing and the motor being stopped.

This project has shown how easy it is to set up and get the MiniZed controlling one or several motors.

The MiniZed might be mini but it is mighty

See previous projects here.

Additional Information on Xilinx FPGA / SoC Development can be found weekly on MicroZed Chronicles.